home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / gdb / gdb_18s.zoo / valops.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-25  |  20.9 KB  |  780 lines
  1. /* Perform non-arithmetic operations on values, for GDB.
  2.    Copyright (C) 1986, 1987 Free Software Foundation, Inc.
  3.  
  4. GDB is distributed in the hope that it will be useful, but WITHOUT ANY
  5. WARRANTY.  No author or distributor accepts responsibility to anyone
  6. for the consequences of using it or for whether it serves any
  7. particular purpose or works at all, unless he says so in writing.
  8. Refer to the GDB General Public License for full details.
  9.  
  10. Everyone is granted permission to copy, modify and redistribute GDB,
  11. but only under the conditions described in the GDB General Public
  12. License.  A copy of this license is supposed to have been given to you
  13. along with GDB so you can know your rights and responsibilities.  It
  14. should be in a file named COPYING.  Among other things, the copyright
  15. notice and this notice must be preserved on all copies.
  16.  
  17. In other words, go ahead and share GDB, but don't try to stop
  18. anyone else from sharing it farther.  Help stamp out software hoarding!
  19. */
  20.  
  21. #include "defs.h"
  22. #include "param.h"
  23. #include "symtab.h"
  24. #include "value.h"
  25. #include "frame.h"
  26. #include "inferior.h"
  27.  
  28. #ifdef atarist
  29. extern int gcc_mshort;
  30. #endif
  31.  
  32.  
  33. /* Cast value ARG2 to type TYPE and return as a value.
  34.    More general than a C cast: accepts any two types of the same length,
  35.    and if ARG2 is an lvalue it can be cast into anything at all.  */
  36.  
  37. value
  38. value_cast (type, arg2)
  39.      struct type *type;
  40.      register value arg2;
  41. {
  42.   register enum type_code code1;
  43.   register enum type_code code2;
  44.   register int scalar;
  45.  
  46.   /* Coerce arrays but not enums.  Enums will work as-is
  47.      and coercing them would cause an infinite recursion.  */
  48.   if (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_ENUM)
  49.     COERCE_ARRAY (arg2);
  50.  
  51.   code1 = TYPE_CODE (type);
  52.   code2 = TYPE_CODE (VALUE_TYPE (arg2));
  53.   scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
  54.         || code2 == TYPE_CODE_ENUM);
  55.  
  56.   if (code1 == TYPE_CODE_FLT && scalar)
  57.     return value_from_double (type, value_as_double (arg2));
  58.   else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM)
  59.        && (scalar || code2 == TYPE_CODE_PTR))
  60.     return value_from_long (type, value_as_long (arg2));
  61.   else if (TYPE_LENGTH (type) == TYPE_LENGTH (VALUE_TYPE (arg2)))
  62.     {
  63.       VALUE_TYPE (arg2) = type;
  64.       return arg2;
  65.     }
  66.   else if (VALUE_LVAL (arg2) == lval_memory)
  67.     return value_at (type, VALUE_ADDRESS (arg2) + VALUE_OFFSET (arg2));
  68.   else if (code1 == TYPE_CODE_VOID)
  69.     {
  70.       return value_zero (builtin_type_void, not_lval);
  71.     }
  72.   else
  73.     error ("Invalid cast.");
  74. }
  75.  
  76. /* Create a value of type TYPE that is zero, and return it.  */
  77.  
  78. value
  79. value_zero (type, lv)
  80.      struct type *type;
  81.      enum lval_type lv;
  82. {
  83.   register value val = allocate_value (type);
  84.  
  85.   bzero (VALUE_CONTENTS (val), TYPE_LENGTH (type));
  86.   VALUE_LVAL (val) = lv;
  87.  
  88.   return val;
  89. }
  90.  
  91. /* Return the value with a specified type located at specified address.  */
  92.  
  93. value
  94. value_at (type, addr)
  95.      struct type *type;
  96.      CORE_ADDR addr;
  97. {
  98.   register value val = allocate_value (type);
  99.  
  100.   read_memory (addr, VALUE_CONTENTS (val), TYPE_LENGTH (type));
  101.   VALUE_LVAL (val) = lval_memory;
  102.   VALUE_ADDRESS (val) = addr;
  103.  
  104.   return val;
  105. }
  106.  
  107. /* Store the contents of FROMVAL into the location of TOVAL.
  108.    Return a new value with the location of TOVAL and contents of FROMVAL.  */
  109.  
  110. value
  111. value_assign (toval, fromval)
  112.      register value toval, fromval;
  113. {
  114.   register struct type *type = VALUE_TYPE (toval);
  115.   register value val;
  116.   char raw_buffer[MAX_REGISTER_RAW_SIZE];
  117.   char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
  118.   int use_buffer = 0;
  119.  
  120.   COERCE_ARRAY (fromval);
  121.  
  122.   if (VALUE_LVAL (toval) != lval_internalvar)
  123.     fromval = value_cast (type, fromval);
  124.  
  125.   /* If TOVAL is a special machine register requiring conversion
  126.      of program values to a special raw format,
  127.      convert FROMVAL's contents now, with result in `raw_buffer',
  128.      and set USE_BUFFER to the number of bytes to write.  */
  129.      
  130.   if (VALUE_REGNO (toval) >= 0
  131.       && REGISTER_CONVERTIBLE (VALUE_REGNO (toval)))
  132.     {
  133.       int regno = VALUE_REGNO (toval);
  134.       if (VALUE_TYPE (fromval) != REGISTER_VIRTUAL_TYPE (regno))
  135.     fromval = value_cast (REGISTER_VIRTUAL_TYPE (regno), fromval);
  136.       bcopy (VALUE_CONTENTS (fromval), virtual_buffer,
  137.          REGISTER_VIRTUAL_SIZE (regno));
  138.       REGISTER_CONVERT_TO_RAW (regno, virtual_buffer, raw_buffer);
  139.       use_buffer = REGISTER_RAW_SIZE (regno);
  140.     }
  141.  
  142.   switch (VALUE_LVAL (toval))
  143.     {
  144.     case lval_internalvar:
  145.       set_internalvar (VALUE_INTERNALVAR (toval), fromval);
  146.       break;
  147.  
  148.     case lval_internalvar_component:
  149.       set_internalvar_component (VALUE_INTERNALVAR (toval),
  150.                  VALUE_OFFSET (toval),
  151.                  VALUE_BITPOS (toval),
  152.                  VALUE_BITSIZE (toval),
  153.                  fromval);
  154.       break;
  155.  
  156.     case lval_memory:
  157.       if (VALUE_BITSIZE (toval))
  158.     {
  159.       int val;
  160.       read_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
  161.                &val, sizeof val);
  162.       modify_field (&val, value_as_long (fromval),
  163.             VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
  164.       write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
  165.             &val, sizeof val);
  166.     }
  167.       else if (use_buffer)
  168.     write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
  169.               raw_buffer, use_buffer);
  170.       else
  171.     write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
  172.               VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
  173.       break;
  174.  
  175.     case lval_register:
  176.       if (VALUE_BITSIZE (toval))
  177.     {
  178.       int val;
  179.  
  180.       read_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
  181.                    &val, sizeof val);
  182.       modify_field (&val, value_as_long (fromval),
  183.             VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
  184.       write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
  185.                 &val, sizeof val);
  186.     }
  187.       else if (use_buffer)
  188.     write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
  189.                   raw_buffer, use_buffer);
  190.       else
  191.     write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
  192.                   VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
  193.       break;
  194.  
  195.     default:
  196.       error ("Left side of = operation is not an lvalue.");
  197.     }
  198.  
  199. #if 1
  200.   /* Return a value just like TOVAL except with the contents of FROMVAL
  201.      (except in the case of the type if TOVAL is an internalvar).  */
  202.  
  203.   if (VALUE_LVAL (toval) == lval_internalvar
  204.       || VALUE_LVAL (toval) == lval_internalvar_component)
  205.     {
  206.       type = VALUE_TYPE (fromval);
  207.     }
  208.  
  209.   val = allocate_value (type);
  210.   bcopy (toval, val, VALUE_CONTENTS_RAW (val) - (char *) val);
  211.   bcopy (VALUE_CONTENTS (fromval), VALUE_CONTENTS_RAW (val), TYPE_LENGTH (type));
  212.   VALUE_TYPE (val) = type;
  213.   
  214.   return val;
  215. #else
  216.   /* Return a value just like TOVAL except with the contents of FROMVAL.  */
  217.  
  218.   val = allocate_value (type);
  219.   bcopy (toval, val, VALUE_CONTENTS (val) - (char *) val);
  220.   bcopy (VALUE_CONTENTS (fromval), VALUE_CONTENTS (val), TYPE_LENGTH (type));
  221.  
  222.   return val;
  223. #endif
  224. }
  225.  
  226. /* Extend a value VAL to COUNT repetitions of its type.  */
  227.  
  228. value
  229. value_repeat (arg1, count)
  230.      value arg1;
  231.      int count;
  232. {
  233.   register value val;
  234.  
  235.   if (VALUE_LVAL (arg1) != lval_memory)
  236.     error ("Only values in memory can be extended with '@'.");
  237.   if (count < 1)
  238.     error ("Invalid number %d of repetitions.", count);
  239.  
  240.   val = allocate_repeat_value (VALUE_TYPE (arg1), count);
  241.  
  242.   read_memory (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1),
  243.            VALUE_CONTENTS (val),
  244.            TYPE_LENGTH (VALUE_TYPE (val)) * count);
  245.   VALUE_LVAL (val) = lval_memory;
  246.   VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1);
  247.  
  248.   return val;
  249. }
  250.  
  251. value
  252. value_of_variable (var)
  253.      struct symbol *var;
  254. {
  255.   value val;
  256.  
  257.   val = read_var_value (var, (CORE_ADDR) 0);
  258.   if (val == 0)
  259.     error ("Address of symbol \"%s\" is unknown.", SYMBOL_NAME (var));
  260.   return val;
  261. }
  262.  
  263. /* Given a value which is an array, return a value which is
  264.    a pointer to its first element.  */
  265.  
  266. value
  267. value_coerce_array (arg1)
  268.      value arg1;
  269. {
  270.   register struct type *type;
  271.   register value val;
  272.  
  273.   if (VALUE_LVAL (arg1) != lval_memory)
  274.     error ("Attempt to take address of value not located in memory.");
  275.  
  276.   /* Get type of elements.  */
  277.   if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_ARRAY)
  278.     type = TYPE_TARGET_TYPE (VALUE_TYPE (arg1));
  279.   else
  280.     /* A phony array made by value_repeat.
  281.        Its type is the type of the elements, not an array type.  */
  282.     type = VALUE_TYPE (arg1);
  283.  
  284.   /* Get the type of the result.  */
  285.   type = lookup_pointer_type (type);
  286.   val = value_from_long (builtin_type_long,
  287.              VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1));
  288.   VALUE_TYPE (val) = type;
  289.   return val;
  290. }
  291.  
  292. /* Given a value which is a function, return a value which is a pointer
  293.    to it.  */
  294.  
  295. value
  296. value_coerce_function (arg1)
  297.      value arg1;
  298. {
  299.   register struct type *type;
  300.   register value val;
  301.  
  302.   if (VALUE_LVAL (arg1) != lval_memory)
  303.     error ("Attempt to take address of value not located in memory.");
  304.  
  305.   /* Get the type of the result.  */
  306.   type = lookup_pointer_type (VALUE_TYPE (arg1));
  307.   val = value_from_long (builtin_type_long,
  308.         (long) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
  309.   VALUE_TYPE (val) = type;
  310.   return val;
  311. }  
  312.  
  313. /* Return a pointer value for the object for which ARG1 is the contents.  */
  314.  
  315. value
  316. value_addr (arg1)
  317.      value arg1;
  318. {
  319.   register struct type *type;
  320.   register value val;
  321.  
  322.   COERCE_REF(arg1);
  323.   /* Taking the address of an array is really a no-op
  324.      once the array is coerced to a pointer to its first element.  */
  325.   if (VALUE_REPEATED (arg1)
  326.       || TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_ARRAY)
  327.     return value_coerce_array (arg1);
  328.   if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_FUNC)
  329.     return value_coerce_function (arg1);
  330.  
  331.   if (VALUE_LVAL (arg1) != lval_memory)
  332.     error ("Attempt to take address of value not located in memory.");
  333.  
  334.   /* Get the type of the result.  */
  335.   type = lookup_pointer_type (VALUE_TYPE (arg1));
  336.   val = value_from_long (builtin_type_long,
  337.         (long) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
  338.   VALUE_TYPE (val) = type;
  339.   return val;
  340. }
  341.  
  342. /* Given a value of a pointer type, apply the C unary * operator to it.  */
  343.  
  344. value
  345. value_ind (arg1)
  346.      value arg1;
  347. {
  348.   COERCE_ARRAY (arg1);
  349.  
  350.   /* Allow * on an integer so we can cast it to whatever we want.  */
  351.   if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_INT)
  352.     return value_at (builtin_type_long, 
  353.              (CORE_ADDR) value_as_long (arg1));
  354.   else if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
  355.     return value_at (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)),
  356.              (CORE_ADDR) value_as_long (arg1));
  357.   error ("Attempt to take contents of a non-pointer value.");
  358.   return 0; /* not reached */
  359. }
  360.  
  361. /* Pushing small parts of stack frames.  */
  362.  
  363. /* Push one word (the size of object that a register holds).  */
  364.  
  365. CORE_ADDR
  366. push_word (sp, buffer)
  367.      CORE_ADDR sp;
  368.      REGISTER_TYPE buffer;
  369. {
  370.   register int len = sizeof (REGISTER_TYPE);
  371.  
  372. #if 1 INNER_THAN 2
  373.   sp -= len;
  374.   write_memory (sp, &buffer, len);
  375. #else /* stack grows upward */
  376.   write_memory (sp, &buffer, len);
  377.   sp += len;
  378. #endif /* stack grows upward */
  379.  
  380.   return sp;
  381. }
  382.  
  383. /* Push LEN bytes with data at BUFFER.  */
  384.  
  385. CORE_ADDR
  386. push_bytes (sp, buffer, len)
  387.      CORE_ADDR sp;
  388.      char *buffer;
  389.      int len;
  390. {
  391. #if 1 INNER_THAN 2
  392.   sp -= len;
  393.   write_memory (sp, buffer, len);
  394. #else /* stack grows upward */
  395.   write_memory (sp, buffer, len);
  396.   sp += len;
  397. #endif /* stack grows upward */
  398.  
  399.   return sp;
  400. }
  401.  
  402. /* Push onto the stack the specified value VALUE.  */
  403.  
  404. CORE_ADDR
  405. value_push (sp, arg)
  406.      register CORE_ADDR sp;
  407.      value arg;
  408. {
  409.   register int len = TYPE_LENGTH (VALUE_TYPE (arg));
  410.  
  411. #if 1 INNER_THAN 2
  412.   sp -= len;
  413.   write_memory (sp, VALUE_CONTENTS (arg), len);
  414. #else /* stack grows upward */
  415.   write_memory (sp, VALUE_CONTENTS (arg), len);
  416.   sp += len;
  417. #endif /* stack grows upward */
  418.  
  419.   return sp;
  420. }
  421.  
  422. /* Perform the standard coercions that are specified
  423.    for arguments to be passed to C functions.  */
  424.  
  425. #ifndef atarist
  426. value
  427. value_arg_coerce (arg)
  428.      value arg;
  429. {
  430.   register struct type *type;
  431.  
  432.   COERCE_ENUM (arg);
  433.  
  434.   type = VALUE_TYPE (arg);
  435.  
  436.   if (TYPE_CODE (type) == TYPE_CODE_INT
  437.       && TYPE_LENGTH (type) < sizeof (int))
  438.     return value_cast (builtin_type_int, arg);
  439.  
  440.   if (type == builtin_type_float)
  441.     return value_cast (builtin_type_double, arg);
  442.  
  443.   return arg;
  444. }
  445. #else
  446. value
  447. value_arg_coerce (arg)
  448.      value arg;
  449. {
  450.   register struct type *type;
  451.  
  452.   COERCE_ENUM (arg);
  453.  
  454.   type = VALUE_TYPE (arg);
  455.  
  456.   if(gcc_mshort)
  457.   {
  458.     if (TYPE_CODE (type) == TYPE_CODE_INT
  459.         && TYPE_LENGTH (type) < sizeof (short))
  460.       return value_cast (builtin_type_short, arg);
  461.   }
  462.   else
  463.   {
  464.     if (TYPE_CODE (type) == TYPE_CODE_INT
  465.         && TYPE_LENGTH (type) < sizeof (int))
  466.       return value_cast (builtin_type_int, arg);
  467.   }
  468.   if (type == builtin_type_float)
  469.     return value_cast (builtin_type_double, arg);
  470.  
  471.   return arg;
  472. }
  473. #endif
  474.  
  475. /* Push the value ARG, first coercing it as an argument
  476.    to a C function.  */
  477.  
  478. CORE_ADDR
  479. value_arg_push (sp, arg)
  480.      register CORE_ADDR sp;
  481.      value arg;
  482. {
  483.   return value_push (sp, value_arg_coerce (arg));
  484. }
  485.  
  486.  
  487. /* Determine a function's address and its return type from its value. 
  488.    Calls error() if the function is not valid for calling.  */
  489.  
  490. CORE_ADDR
  491. find_function_addr (function, retval_type)
  492.      value function;
  493.      struct type **retval_type;
  494. {
  495.   register struct type *ftype = VALUE_TYPE (function);
  496.   register enum type_code code = TYPE_CODE (ftype);
  497.   struct type *value_type;
  498.   CORE_ADDR funaddr;
  499.  
  500.   /* If it's a member function, just look at the function
  501.      part of it.  */
  502.  
  503.   /* Determine address to call.  */
  504.   if (code == TYPE_CODE_FUNC)
  505.     {
  506.       funaddr = VALUE_ADDRESS (function);
  507.       value_type = TYPE_TARGET_TYPE (ftype);
  508.     }
  509.   else if (code == TYPE_CODE_PTR)
  510.     {
  511.       funaddr = value_as_long (function);
  512.       if (TYPE_CODE (TYPE_TARGET_TYPE (ftype)) == TYPE_CODE_FUNC)
  513.     value_type = TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype));
  514.       else
  515.     value_type = builtin_type_int;
  516.     }
  517.   else if (code == TYPE_CODE_INT)
  518.     {
  519.       /* Handle the case of functions lacking debugging info.
  520.      Their values are characters since their addresses are char */
  521.       if (TYPE_LENGTH (ftype) == 1)
  522.     funaddr = value_as_long (value_addr (function));
  523.       else
  524.     /* Handle integer used as address of a function.  */
  525.     funaddr = (CORE_ADDR) value_as_long (function);
  526.  
  527. #ifdef atarist
  528.       if(gcc_mshort && (TYPE_LENGTH(ftype) < sizeof(int)))
  529.     value_type = builtin_type_short;
  530.       else
  531. #endif
  532.         value_type = builtin_type_int;
  533.     }
  534.   else
  535.     error ("Invalid data type for function to be called.");
  536.  
  537.   *retval_type = value_type;
  538.   return funaddr;
  539. }
  540.  
  541. /* Perform a function call in the inferior.
  542.    ARGS is a vector of values of arguments (NARGS of them).
  543.    FUNCTION is a value, the function to be called.
  544.    Returns a value representing what the function returned.
  545.    May fail to return, if a breakpoint or signal is hit
  546.    during the execution of the function.  */
  547.  
  548. value
  549. call_function (function, nargs, args)
  550.      value function;
  551.      int nargs;
  552.      value *args;
  553. {
  554.   register CORE_ADDR sp;
  555.   register int i;
  556.   CORE_ADDR start_sp;
  557.   /* CALL_DUMMY is an array of words (REGISTER_TYPE), but each word
  558.      in in host byte order.  It is switched to target byte order before calling
  559.      FIX_CALL_DUMMY.  */
  560.   static REGISTER_TYPE dummy[] = CALL_DUMMY;
  561.   REGISTER_TYPE dummy1[sizeof dummy / sizeof (REGISTER_TYPE)];
  562.   CORE_ADDR old_sp;
  563.   struct type *value_type;
  564.   unsigned char struct_return;
  565.   CORE_ADDR struct_addr;
  566.   CORE_ADDR funaddr;
  567.   int using_gcc;
  568.   struct cleanup *old_chain;
  569.   struct inferior_status inf_status;
  570.  
  571.   save_inferior_status (&inf_status, 1);
  572.   old_chain = make_cleanup (restore_inferior_status, &inf_status);
  573.  
  574.   /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
  575.      (and POP_FRAME for restoring them).  (At least on most machines)
  576.      they are saved on the stack in the inferior.  */
  577.   PUSH_DUMMY_FRAME;
  578.  
  579.   old_sp = sp = read_register (SP_REGNUM);
  580.  
  581. #if 1 INNER_THAN 2        /* Stack grows down */
  582.   sp -= sizeof dummy;
  583.   start_sp = sp;
  584. #else                /* Stack grows up */
  585.   start_sp = sp;
  586.   sp += sizeof dummy;
  587. #endif
  588.  
  589.   funaddr = find_function_addr (function, &value_type);
  590.  
  591.   using_gcc = 1;
  592.   
  593.   /* Are we returning a value using a structure return or a normal
  594.      value return? */
  595.  
  596.   struct_return = using_struct_return (function, funaddr, value_type,
  597.                        using_gcc);
  598.  
  599.   /* Create a call sequence customized for this function
  600.      and the number of arguments for it.  */
  601.   bcopy (dummy, dummy1, sizeof dummy);
  602.   FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
  603.           value_type, using_gcc);
  604.  
  605.   write_memory (start_sp, (char *)dummy1, sizeof dummy);
  606.  
  607. #ifdef lint
  608.   sp = old_sp;        /* It really is used, for some ifdef's... */
  609. #endif
  610.  
  611.     /* Reserve space for the return structure to be written on the
  612.        stack, if necessary */
  613.  
  614.     if (struct_return)
  615.       {
  616. #if 1 INNER_THAN 2
  617.     sp -= TYPE_LENGTH (value_type);
  618.     struct_addr = sp;
  619. #else
  620.     struct_addr = sp;
  621.     sp += TYPE_LENGTH (value_type);
  622. #endif
  623.       }
  624.  
  625.   for (i = nargs - 1; i >= 0; i--)
  626.     sp = value_arg_push (sp, args[i]);
  627.  
  628.   /* Store the address at which the structure is supposed to be
  629.      written.  Note that this (and the code which reserved the space
  630.      above) assumes that gcc was used to compile this function.  Since
  631.      it doesn't cost us anything but space and if the function is pcc
  632.      it will ignore this value, we will make that assumption.
  633.  
  634.      Also note that on some machines (like the sparc) pcc uses a 
  635.      convention like gcc's.  */
  636.  
  637.   if (struct_return)
  638.     STORE_STRUCT_RETURN (struct_addr, sp);
  639.  
  640.   /* Write the stack pointer.  This is here because the statements above
  641.      might fool with it.  On SPARC, this write also stores the register
  642.      window into the right place in the new stack frame, which otherwise
  643.      wouldn't happen.  (See write_inferior_registers in sparc-xdep.c.)  */
  644.   write_register (SP_REGNUM, sp);
  645.  
  646.   /* Figure out the value returned by the function.  */
  647.   {
  648.     char retbuf[REGISTER_BYTES];
  649.  
  650.     /* Execute the stack dummy routine, calling FUNCTION.
  651.        When it is done, discard the empty frame
  652.        after storing the contents of all regs into retbuf.  */
  653.     run_stack_dummy (start_sp + CALL_DUMMY_START_OFFSET, retbuf);
  654.  
  655.     do_cleanups (old_chain);
  656.  
  657.     return value_being_returned (value_type, retbuf, struct_return);
  658.   }
  659. }
  660.  
  661. /* Create a value for a string constant:
  662.    Call the function malloc in the inferior to get space for it,
  663.    then copy the data into that space
  664.    and then return the address with type char *.
  665.    PTR points to the string constant data; LEN is number of characters.  */
  666.  
  667. value
  668. value_string (ptr, len)
  669.      char *ptr;
  670.      int len;
  671. {
  672.   register value val;
  673.   register struct symbol *sym;
  674.   value blocklen;
  675.   register char *copy = (char *) alloca (len + 1);
  676.   char *i = ptr;
  677.   register char *o = copy, *ibeg = ptr;
  678.   register int c;
  679.  
  680.   /* Copy the string into COPY, processing escapes.
  681.      We could not conveniently process them in expread
  682.      because the string there wants to be a substring of the input.  */
  683.  
  684.   while (i - ibeg < len)
  685.     {
  686.       c = *i++;
  687.       if (c == '\\')
  688.     {
  689.       c = parse_escape (&i);
  690.       if (c == -1)
  691.         continue;
  692.     }
  693.       *o++ = c;
  694.     }
  695.   *o = 0;
  696.  
  697.   /* Get the length of the string after escapes are processed.  */
  698.  
  699.   len = o - copy;
  700.  
  701.   /* Find the address of malloc in the inferior.  */
  702.  
  703.   sym = lookup_symbol ("malloc", 0, VAR_NAMESPACE);
  704.   if (sym != 0)
  705.     {
  706.       if (SYMBOL_CLASS (sym) != LOC_BLOCK)
  707.     error ("\"malloc\" exists in this program but is not a function.");
  708.       val = value_of_variable (sym);
  709.     }
  710.   else
  711.     {
  712.       register int i;
  713.       for (i = 0; i < misc_function_count; i++)
  714.     if (!strcmp (misc_function_vector[i].name, "malloc"))
  715.       break;
  716.       if (i < misc_function_count)
  717.     val = value_from_long (builtin_type_long,
  718.                    misc_function_vector[i].address);
  719.       else
  720.     error ("String constants require the program to have a function \"malloc\".");
  721.     }
  722.  
  723.   blocklen = value_from_long (builtin_type_int, len + 1);
  724.   val = call_function (val, 1, &blocklen);
  725.   if (value_zerop (val))
  726.     error ("No memory available for string constant.");
  727.   write_memory (value_as_long (val), copy, len + 1);
  728.   VALUE_TYPE (val) = lookup_pointer_type (builtin_type_char);
  729.   return val;
  730. }
  731.  
  732. /* Given ARG1, a value of type (pointer to a)* structure/union,
  733.    extract the component named NAME from the ultimate target structure/union
  734.    and return it as a value with its appropriate type.
  735.    ERR is used in the error message if ARG1's type is wrong.  */
  736.    
  737. value
  738. value_struct_elt (arg1, name, err)
  739.      register value arg1;
  740.      char *name;
  741.      char *err;
  742. {
  743.   register struct type *t;
  744.   register int i;
  745.  
  746.   COERCE_ARRAY (arg1);
  747.  
  748.   t = VALUE_TYPE (arg1);
  749.  
  750.   /* Follow pointers until we get to a non-pointer.  */
  751.  
  752.   while (TYPE_CODE (t) == TYPE_CODE_PTR)
  753.     {
  754.       arg1 = value_ind (arg1);
  755.       /* Don't coerce fn pointer to fn and then back again!  */
  756.       if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_FUNC)
  757.         COERCE_ARRAY (arg1);
  758.       t = VALUE_TYPE (arg1);
  759.     }
  760.  
  761.   if (TYPE_CODE (t) != TYPE_CODE_STRUCT
  762.       &&
  763.       TYPE_CODE (t) != TYPE_CODE_UNION)
  764.     error ("Attempt to extract a component of a value that is not a %s.", err);
  765.  
  766.   for (i = TYPE_NFIELDS (t) - 1; i >= 0; i--)
  767.     {
  768.       if (!strcmp (TYPE_FIELD_NAME (t, i), name))
  769.     break;
  770.     }
  771.  
  772.   if (i < 0)
  773.     error ("Structure has no component named %s.", name);
  774.  
  775.   return value_field (arg1, i);
  776. }
  777. void
  778. initialize_valops ()
  779. { }
  780.